//#include "spi.h"
//#include "hpm_spi_drv.h"              // SPI 驱动
//#include "uart.h"
//#include "can.h"




//// 全局变量
//uint8_t spi_rx_buffer[256];           // SPI接收缓冲区











///* 辅助函数：配置SPI发送 */
//void setup_spi_transfer(uint8_t *data, uint32_t length) {
//    sent_buff = data;
//    sent_count = (length + 3) / 4;    // 转换为4字节块数
//    receive_buff = spi_rx_buffer;
//    receive_count = 0;                // 不接收数据
    
//    // 启用SPI发送相关中断
//    spi_enable_interrupt(TEST_SPI, spi_slave_cmd_int);
//}



///* 辅助函数：发送CAN帧并处理公共逻辑 */
//void send_can_frame(MCAN_Type *can_base, uint16_t *frame_id, uint8_t *data_ptr, uint8_t chunk_size)
//{
//    mcan_tx_frame_t tx_frame;
//    memset(&tx_frame, 0, sizeof(mcan_tx_frame_t));
    
//    tx_frame.std_id = (*frame_id)++;  // 使用递增ID
//    tx_frame.dlc = chunk_size;
//    tx_frame.rtr = 0;  // 数据帧

//    memcpy(tx_frame.data_8, data_ptr, chunk_size);

//    // 发送CAN帧
//    hpm_stat_t status = mcan_transmit_blocking(can_base, &tx_frame);
//    if (status != status_success) {
//        printf("CAN send error (ID 0x%03X): %d\n", tx_frame.std_id, status);
//    }

//    // 打印发送详情
//    printf("Sent to CAN%c: ID=0x%03X, DLC=%d, Data=", 
//           (can_base == CAN_CHANNEL_4) ? '4' : '0',
//           tx_frame.std_id, 
//           tx_frame.dlc);
//    for (int i = 0; i < chunk_size; i++) {
//        printf("0x%02X ", tx_frame.data_8[i]);
//    }
//    printf("\r\n");
    
//    // 帧间延时
//    board_delay_us(50);
//}


///* 处理SPI接收数据并发送到CAN，前64字节发CAN4，后64字节发CAN0 */
//void process_spi_data_to_can(uint8_t *data, uint16_t length)
//{
//    if (!data || length == 0) return;  // 检查数据有效性

//    // 定义CAN通道配置
//    struct {
//        MCAN_Type *base;
//        uint16_t start_id;
//    } channels[2] = {
//        {CAN_CHANNEL_4, 0x124},  // 前64字节 -> CAN4 (ID:0x124起)
//        {CAN_CHANNEL_1, 0x200}   // 后64字节 -> CAN0 (ID:0x200起)
//    };

//    // 处理前64字节 (CAN4)
//    uint16_t offset = 0;
//    uint16_t frame_id = channels[0].start_id;
//    uint16_t first_part_len = (length > 64) ? 64 : length;
    
//    while (offset < first_part_len) {
//        uint8_t chunk_size = (first_part_len - offset > 8) ? 8 : (first_part_len - offset);
//        send_can_frame(channels[0].base, &frame_id, data + offset, chunk_size);
//        offset += chunk_size;
//    }

//    // 处理后64字节 (CAN0)
//    if (length > 64) {
//        offset = 64;  // 跳过后64字节
//        frame_id = channels[1].start_id;
        
//        while (offset < length) {
//            uint8_t chunk_size = (length - offset > 8) ? 8 : (length - offset);
//            send_can_frame(channels[1].base, &frame_id, data + offset, chunk_size);
//            offset += chunk_size;
//        }
//    }
//}
//// SPI 中断服务函数
//void spi_isr(void)
//{
//    volatile uint32_t irq_status;  // 中断状态
//    uint8_t data_len_in_bytes;     // 数据长度（字节）
//    hpm_stat_t stat;               // 操作状态

//    // 获取 SPI 数据长度（字节）
//    data_len_in_bytes = spi_get_data_length_in_bytes(TEST_SPI);
//    // 获取 SPI 中断状态
//    irq_status = spi_get_interrupt_status(TEST_SPI);
    
//    // 从机命令中断
//    if (irq_status & spi_slave_cmd_int) {
//        spi_disable_interrupt(TEST_SPI, spi_slave_cmd_int);  // 禁用当前中断
//        // 启用传输相关中断
//        spi_enable_interrupt(TEST_SPI, spi_tx_fifo_threshold_int | spi_rx_fifo_threshold_int | spi_end_int);
//        spi_transfer_done = false;  // 重置传输完成标志
//    }
    
//    // 传输结束中断
//    if (irq_status & spi_end_int) {
//        spi_transfer_done = true;  // 设置传输完成标志
//        spi_clear_interrupt_status(TEST_SPI, spi_end_int);  // 清除中断状态
//        // 禁用传输相关中断
//        spi_disable_interrupt(TEST_SPI, spi_end_int | spi_tx_fifo_threshold_int |spi_rx_fifo_threshold_int);
//        spi_enable_interrupt(TEST_SPI, spi_slave_cmd_int);  // 重新启用命令中断
//        spi_transmit_fifo_reset(TEST_SPI);  // 复位发送 FIFO
//        spi_receive_fifo_reset(TEST_SPI);   // 复位接收 FIFO
//    }
    
//    // 接收 FIFO 阈值中断
//    if (irq_status & spi_rx_fifo_threshold_int) {
//        // 从 SPI 读取数据
//        stat = spi_read_data(TEST_SPI, data_len_in_bytes, receive_buff, 1);
//        if (stat != status_success) {
//            printf("spi read data filed, error: %d\n", stat);  // 读取错误报告
//        }
//        spi_clear_interrupt_status(TEST_SPI, spi_rx_fifo_threshold_int);  // 清除中断状态

//        receive_buff += data_len_in_bytes;  // 移动接收缓冲区指针
//        receive_count--;  // 减少待接收计数
//        if (receive_count == 0) {
//            spi_disable_interrupt(TEST_SPI, spi_rx_fifo_threshold_int);  // 禁用中断
//        }
//    }
    
//    // 发送 FIFO 阈值中断
//    if (irq_status & spi_tx_fifo_threshold_int) {
//        // 向 SPI 写入数据
//        stat = spi_write_data(TEST_SPI, data_len_in_bytes, sent_buff, 1);
//        if (stat != status_success) {
//            printf("spi write data filed, error: %d\n", stat);  // 写入错误报告
//        }
//        spi_clear_interrupt_status(TEST_SPI, spi_tx_fifo_threshold_int);  // 清除中断状态

//        sent_buff += data_len_in_bytes;  // 移动发送缓冲区指针
//        sent_count--;  // 减少待发送计数
//        if (sent_count == 0) {
//            spi_disable_interrupt(TEST_SPI, spi_tx_fifo_threshold_int);  // 禁用中断
//        }
//    }
//}
//// 声明 SPI 中断服务函数
//SDK_DECLARE_EXT_ISR_M(TEST_SPI_IRQ, spi_isr)